angular.module('starter.common.service', [])

  // 对请求进行签名
  .factory('$$SignService', function($rootScope) {
    console.info("factory----------$$SignService");
    return {
      // 对参数进行签名
      sign: function(data) {
        data.time = $rootScope.serverTime;
        for (var key in data) {
          if (data[key] === null || data[key] === undefined) {
            delete data[key];
          }
        }
        var paramsSign = Object.keys(data).filter(function(key) {
          if (key == 'sign') return false;
          // if (data[key] == '') return false;
          return true;
        }).sort().map(function(key) {
          return [key, data[key]].join('=');
        }).join('&');
        paramsSign = paramsSign + '&key=' + $rootScope.config.secretkey;
        // console.log(paramsSign);
        data.sign = md5(paramsSign);
        console.info("%c 请求参数", "font-size:14px;color:blue;font-weight:bold;");
        console.log(data);
        return data;
      },
      // 对参数进行签名
      signToGet: function(data) {
        // console.log(data);
        data.time = $rootScope.serverTime;
        for (var key in data) {
          if (data[key] === null || data[key] === undefined) {
            delete data[key];
          }
        }
        // console.log(data);
        var paramsSign = Object.keys(data).filter(function(key) {
          if (key == 'sign') return false;
          // if (data[key] == '') return false;
          return true;
        }).sort().map(function(key) {
          return [key, data[key]].join('=');
        }).join('&');
        // console.log(paramsSign);
        paramsSign = paramsSign + '&key=' + $rootScope.config.secretkey;
        // console.log(paramsSign);
        // alert(paramsSign);
        data.sign = md5(paramsSign);
        console.info("%c 请求参数", "font-size:14px;color:blue;font-weight:bold;");
        console.log(data);
        paramsSign = Object.keys(data).filter(function(key) {
          // if (key == 'sign') return false;
          // if (data[key] == '') return false;
          return true;
        }).sort().map(function(key) {
          return [key, data[key]].join('=');
        }).join('&');
        // console.log(paramsSign);
        return encodeURI(paramsSign);
      }
    };
  })

  // $http 封装
  .factory('$$HttpService', function($rootScope, $location, $timeout, $$SignService, $$UserDataService, $http, $ionicLoading, $$TimeService, $q) {
    console.info("factory----------$$HttpService");
    return {
      // 先请求服务器时间
      // 回调成功后再调用响应接口
      timepost: function(url, reqdata) {
        // 需要用户 token
        if ($rootScope.userData.token != undefined && $rootScope.userData.token != "" && $rootScope.userData.token != null) {
          reqdata.token = $rootScope.userData.token;
        }
        // $q promise对象
        var defer = $q.defer();
        // 请求服务器时间
        $$TimeService.getServerTime({})
          .success(function(res_time) {
            console.log(res_time);
            $rootScope.serverTime = res_time.time;
            console.log("服务器时间 serverTime: ", $rootScope.serverTime);

            $http.post((url == "api/upload" ? $rootScope.config.serverHost : $rootScope.config.apiHost) + url, $$SignService.sign(reqdata), { cache: false })
              .success(function(res) {
                console.info("%c请求结果 "+url, 'color:#03a9f4');
                console.log(res);
                if (res.errCode == 421 || res.errCode == 422 || res.errCode == 420) { // token 过期
                  $ionicLoading.show({
                    template: "请登录",
                    noBackdrop: true,
                    duration: 1500
                  });
                  $timeout(function() {
                    $location.path("login");
                  }, 1500);
                  // $rootScope.needReLogin();
                }
                // 如果服务器返回token 则更新 $rootScope.userData 并且更新本地缓存用户数据
                if (res.token) {
                  $rootScope.userData.token = res.token;
                  $$UserDataService.updateUserData($rootScope.userData);
                }
                // 返回正确结果
                if (res.errCode == 203 || res.errCode == 200 || res.errCode == 201) {
                  defer.resolve(res);
                } else {
                  $ionicLoading.show({
                    template: res.msg,
                    noBackdrop: true,
                    duration: 1500
                  });
                  defer.reject(res);
                }
              })
              .error(function(errordata, status, headers, config) {
                $ionicLoading.show({
                  template: "网络请求异常",
                  noBackdrop: true,
                  duration: 1500
                });
                console.error(errordata);
                console.error(status);
                console.error(config);
                defer.reject();
              });

          });
        return defer.promise;
      },
      // 远程服务器的图片上传请求
      // 先请求服务器时间
      // 回调成功后再调用响应接口
      timepostimageupload: function(url, reqdata) {
        // 需要用户 token
        if ($rootScope.userData.token != null && $rootScope.userData.token != "" && $rootScope.userData.token != undefined) {
          reqdata.token = $rootScope.userData.token;
        }
        // $q promise对象
        var defer = $q.defer();
        // 请求服务器时间
        $http.get($rootScope.config.serverHost + "api/options/serverTime", { cache: false })
          .success(function(res_time) {
            console.log(res_time);
            $rootScope.serverTime = res_time.time;
            console.log("服务器时间 serverTime: ", $rootScope.serverTime);

            $http.post((url == "api/upload" ? $rootScope.config.serverHost : $rootScope.config.apiHost) + url, $$SignService.sign(reqdata), { cache: false })
              .success(function(res) {
                console.info("请求结果", url);
                console.log(res);
                if (res.errCode == 421 || res.errCode == 422 || res.errCode == 420) { // token 过期
                  $ionicLoading.show({
                    template: "请登录",
                    noBackdrop: true,
                    duration: 1500
                  });
                  $timeout(function() {
                    $location.path("login");
                  }, 1500);
                  // $rootScope.needReLogin();
                }
                // 如果服务器返回token 则更新 $rootScope.userData 并且更新本地缓存用户数据
                if (res.token) {
                  $rootScope.userData.token = res.token;
                  $$UserDataService.updateUserData($rootScope.userData);
                }
                // 返回正确结果
                if (res.errCode == 203 || res.errCode == 200 || res.errCode == 201) {
                  defer.resolve(res);
                } else {
                  $ionicLoading.show({
                    template: res.msg,
                    noBackdrop: true,
                    duration: 1500
                  });
                  defer.reject(res);
                }
              })
              .error(function(errordata, status, headers, config) {
                $ionicLoading.show({
                  template: "网络请求异常",
                  noBackdrop: true,
                  duration: 1500
                });
                console.error(errordata);
                console.error(status);
                console.error(config);
                defer.reject();
              });

          })
          .error(function(error) {
            $ionicLoading.show({
              template: "图片上传获取时间异常",
              noBackdrop: true,
              duration: 1500
            });
          });
        return defer.promise;
      },
      // 先请求服务器时间
      // 回调成功后再调用响应接口
      timeget: function(url, reqdata) {
        console.log(reqdata);
        // 需要用户 token
        if ($rootScope.userData.token != null && $rootScope.userData.token != "" && $rootScope.userData.token != undefined) {
          reqdata.token = $rootScope.userData.token;
        }
        // $q promise对象
        var defer = $q.defer();
        // 请求服务器时间
        $$TimeService.getServerTime({})
          .success(function(res_time) {
            console.log(res_time);
            $rootScope.serverTime = res_time.time;
            console.log("服务器时间 serverTime: ", $rootScope.serverTime);

            console.log(reqdata);
            $http.get($rootScope.config.apiHost + url + "?" + $$SignService.signToGet(reqdata), { cache: false })
              .success(function(res) {
                console.info("请求结果", url);
                console.log(res);
                // 420 token没有
                // 421 Token过期
                // 422 Token验证失败
                if (res.errCode == 421 || res.errCode == 422 || res.errCode == 420) { // token 过期
                  $ionicLoading.show({
                    template: "请登录",
                    noBackdrop: true,
                    duration: 1500
                  });
                  $timeout(function() {
                    $location.path("login");
                  }, 1500);
                  // $rootScope.needReLogin();
                }
                // 如果服务器返回token 则更新 $rootScope.userData 并且更新本地缓存用户数据
                if (res.token) {
                  $rootScope.userData.token = res.token;
                  $$UserDataService.updateUserData($rootScope.userData);
                }
                // 返回正确结果
                if (res.errCode == 203 || res.errCode == 200) {
                  defer.resolve(res);
                } else {
                  $ionicLoading.show({
                    template: res.msg,
                    noBackdrop: true,
                    duration: 1500
                  });
                  defer.reject(res);
                }
              })
              .error(function(errordata, status, headers, config) {
                console.error(errordata);
                console.error(status);
                console.error(config);
                if (status == -1) {
                  $ionicLoading.show({
                    template: "请求超时",
                    noBackdrop: true,
                    duration: 1500
                  });
                } else {
                  $ionicLoading.show({
                    template: "网络请求异常",
                    noBackdrop: true,
                    duration: 1500
                  });
                }
                defer.reject();
              });

          });
        return defer.promise;
      }
    };
  })

  // 获取服务器时间
  .factory('$$TimeService', function($rootScope, $http, $ionicLoading) {
    console.info("factory----------$$TimeService");
    return {
      getServerTime: function(location) {
        return $http.get($rootScope.config.apiHost + "api/options/serverTime", { cache: false }).error(function(error) {
          $ionicLoading.show({
            template: "获取时间异常",
            noBackdrop: true,
            duration: 1500
          });
        });
      }
    };
  })


  // 图片上传
  .factory('$$UploadImageService', function($rootScope, $http, $$SignService, $$HttpService) {
    console.info("factory----------$$ImageUploadService");
    return {
      uploadImage: function(base64) {
        var req = {
          pic: base64
        };
        return $$HttpService.timepostimageupload("api/upload", req, { cache: false });
      }
    };
  })


  .factory('$$CommonService', function($$HttpService) {
    console.info("factory----------$$ArticleService");
    return {

      // 增加意见反馈
      feedBackUser: function(feedbackData) {
        var data = {
          // feedback: feedbackData,
          comment: feedbackData.comment,
          isAnonymous: feedbackData.isAnonymous || 0,
        };
        return $$HttpService.timepost("api/feedBack", data);
      },
      // 获取大广告
      getAds: function(feedbackData) {
        return $$HttpService.timeget("api/options/getAdvertisement", {});
      },
      // App版本
      getAppVersion: function(versionId, device) {
        var req = {
          versionId: versionId,
          device: device // 1 安卓 2 ios
        };
        return $$HttpService.timeget("api/options/version", req);
      },
      // 获取服务类别目录
      hotCatalog: function() {
        var req = {
          parentId: 0,
          // pageNum: "",
          // pageSize: ""
        };
        return $$HttpService.timeget("api/options/hotCatalog", req);
      }
    };
  })

  // 消息通知获取
  .factory('$$MessageService', function($$LocalStorage, $$HttpService) {
    console.info("factory----------$$MessageService");
    return {

      // 获取通知
      getusernotify: function(feedbackData) {
        return $$HttpService.timeget("api/user/notify", {});
      },
      // 更新通知
      userupdateNotify: function(id, state, type) {
        var req = {
          id: id,
          state: state,
          type: type, //类型 0不删除 1删除
        };
        return $$HttpService.timepost("api/user/updateNotify", req);
      },




      getMessageList: function() {
        return $$LocalStorage.getObj("message") || [];
      },
      setMessageList: function(messagelist) {
        $$LocalStorage.setObj("message", messagelist);
      },
      addMessage: function(message) {
        var messagelist = $$LocalStorage.getObj("message") || [];
        messagelist.push(message);
        $$LocalStorage.setObj("message", messagelist);
      }
    };
  })


  // 文章获取
  .factory('$$ArticleService', function($$HttpService) {
    console.info("factory----------$$ArticleService");
    return {
      // 文章获取
      getArticleById: function(id) {
        var req = {
          id: id
        };
        return $$HttpService.timeget("api/options/declare", req);
      },
    };
  })

  // 城市
  .factory('$$CityService', function($http, $$HttpService) {
    console.info("factory----------$$CityService");

    return {
      // 获取所有城市列表
      getallcitys: function() {
        return $$HttpService.timeget("api/options/citys", {});
      },
      // 根据省市id获取城市列表
      getcitys: function(provinceId) {
        return $$HttpService.timeget("api/options/city", { province_id: provinceId || 27 });
      },
      // 获取省列表
      getprovince: function() {
        return $$HttpService.timeget("api/options/province", {});
      }
    };

  })

  // 获取工作
  .factory('$$JobService', function($http, $$HttpService) {
    console.info("factory----------$$CityService");

    return {
      // 获取工作
      getJobs: function(provinceId) {
        return $$HttpService.timeget("api/options/getJob", {});
      }
    };

  })



  //定位
  .factory('$$GeocoderService', function($rootScope, $http, $ionicPlatform, $q, $$WeixinConfigService, $$cordovaGeolocation) {
    console.info("factory----------$$GeocoderService");
    return {
      getCityBylnglat: function(latLng) {

        var defer = $q.defer();
        // 通过经纬度获得城市信息
        var citylocation = new qq.maps.CityService({
          complete: function(mapsresult) {
            defer.resolve(mapsresult);
          }
        });
        //调用城市服务信息
        citylocation.searchCityByLatLng(new qq.maps.LatLng(latLng.lat, latLng.lng));

        // 返回 promise对象
        return defer.promise;
      },
      getlatLng: function() {

        var defer = $q.defer();

        if ($rootScope.config.isWeixin) {
          getgeolocationByWechatJSSDK();
        } else if ($rootScope.config.isWebView) {
          if ($rootScope.config.isAndroid) {
            document.addEventListener("deviceready", function() {
              // 百度cordova插件进行定位
              baidu_location.getCurrentPosition(function(res) {
                // alert("baidu geolocation" + JSON.stringify(res));
                defer.resolve({
                  lat: res.latitude,
                  lng: res.lontitude
                });
              }, function(err) {
                getgeolocationByCordovaGeolocation();
              });
            }, false); // deviceready
          } else {
            document.addEventListener("deviceready", function() {
              $ionicPlatform.ready(function() {
                getgeolocationByCordovaGeolocation();
              }); // ionicPlatform.ready
            }, false); // deviceready
          }
        } else if (navigator.geolocation) {
          // 浏览器支持定位
          getgeolocationByH5();
        } else {
          defer.reject("定位失败");
        }

        // 地位 CordovaGeolocation
        function getgeolocationByCordovaGeolocation() {
          $$cordovaGeolocation.getCurrentPosition({ timeout: 5000, enableHighAccuracy: false })
            .then(function(position) {
              //WGS-84 to GCJ-02
              var latlng = GPS.gcj_encrypt(position.coords.latitude, position.coords.longitude);
              // 通知页面获取到经纬度
              defer.resolve({
                lat: latlng.lat,
                lng: latlng.lon
              });
            }, function(err) {
              if ($rootScope.config.isAndroid) {
                getgeolocationByCordovaBaidu();
              } else {
                getgeolocationByH5();
              }
            });
        }

        // 地位 百度cordova
        function getgeolocationByCordovaBaidu() {
          // 百度cordova插件进行定位
          baidu_location.getCurrentPosition(function(res) {
            // alert("baidu geolocation" + JSON.stringify(res));
            if (res.latitude != null && res.latitude != undefined) {
              defer.resolve({
                lat: res.latitude,
                lng: res.lontitude
              });
            } else {
              getgeolocationByH5();
            }
          }, function(err) {
            getgeolocationByH5();
          });
        }

        // 地位 浏览器h5
        function getgeolocationByWechatJSSDK() {
          // alert('请求微信 js sdk 支付所需参数');
          $$WeixinConfigService.getWeixinJSConfig()
            .success(function(data) {
              $rootScope.config.weixin = data;
              // 开启微信debug模式
              $rootScope.config.weixin.debug = false;
              wx.config($rootScope.config.weixin);
              // config信息验证后会执行ready方法，所有接口调用都必须在config接口获得结果之后，config是一个客户端的异步操作，所以如果需要在页面加载时就调用相关接口，则须把相关接口放在ready函数中调用来确保正确执行。对于用户触发时才调用的接口，则可以直接调用，不需要放在ready函数中。
              wx.ready(function() {
                wx.error(function(err) {
                  console.log(err);
                  getgeolocationByH5();
                  // config信息验证失败会执行error函数，如签名过期导致验证失败，具体错误信息可以打开config的debug模式查看，也可以在返回的res参数中查看，对于SPA可以在这里更新签名。
                });
                // 获取地理位置接口
                wx.getLocation({
                  type: 'gcj02', // 默认为wgs84的gps坐标，如果要返回直接给openLocation用的火星坐标，可传入'gcj02'
                  success: function(res) {
                    // var speed = res.speed; // 速度，以米/每秒计
                    // var accuracy = res.accuracy; // 位置精度
                    // 返回成功回调
                    defer.resolve({
                      lat: res.latitude,
                      lng: res.longitude
                    });
                  },
                  fail: function(err) {
                    getgeolocationByH5();
                  }
                });
              });
            }).error(function(err) {
              getgeolocationByH5();
            });
        }

        // 地位 浏览器h5
        function getgeolocationByH5() {
          console.log("getgeolocationByH5()");
          navigator.geolocation.getCurrentPosition(function(position) {
            // 通知页面获取到经纬度
            defer.resolve({
              lat: position.coords.latitude,
              lng: position.coords.longitude
            });
          }, function(data) {
            defer.reject("是否开启定位服务");
          });
        }




        // 定位城市
        // 返回 promise对象
        return defer.promise;
      }
    };
  })

;
